// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by google-apis-code-generator 1.5.1
//     C# generator version: 1.22.0
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

/**
 * \brief
 *   Google Cloud Vision API Version v1
 *
 * \section ApiInfo API Version Information
 *    <table>
 *      <tr><th>API
 *          <td><a href='https://cloud.google.com/vision/'>Google Cloud Vision API</a>
 *      <tr><th>API Version<td>v1
 *      <tr><th>API Rev<td>20170314 (803)
 *      <tr><th>API Docs
 *          <td><a href='https://cloud.google.com/vision/'>
 *              https://cloud.google.com/vision/</a>
 *      <tr><th>Discovery Name<td>vision
 *    </table>
 *
 * \section ForMoreInfo For More Information
 *
 * The complete API documentation for using Google Cloud Vision API can be found at
 * <a href='https://cloud.google.com/vision/'>https://cloud.google.com/vision/</a>.
 *
 * For more information about the Google APIs Client Library for .NET, see
 * <a href='https://developers.google.com/api-client-library/dotnet/get_started'>
 * https://developers.google.com/api-client-library/dotnet/get_started</a>
 */

namespace Google.Apis.Vision.v1
{
    /// <summary>The Vision Service.</summary>
    public class VisionService : Google.Apis.Services.BaseClientService
    {
        /// <summary>The API version.</summary>
        public const string Version = "v1";

        /// <summary>The discovery version used to generate this service.</summary>
        public static Google.Apis.Discovery.DiscoveryVersion DiscoveryVersionUsed =
            Google.Apis.Discovery.DiscoveryVersion.Version_1_0;

        /// <summary>Constructs a new service.</summary>
        public VisionService() :
            this(new Google.Apis.Services.BaseClientService.Initializer()) {}

        /// <summary>Constructs a new service.</summary>
        /// <param name="initializer">The service initializer.</param>
        public VisionService(Google.Apis.Services.BaseClientService.Initializer initializer)
            : base(initializer)
        {
            images = new ImagesResource(this);
        }

        /// <summary>Gets the service supported features.</summary>
        public override System.Collections.Generic.IList<string> Features
        {
            get { return new string[0]; }
        }

        /// <summary>Gets the service name.</summary>
        public override string Name
        {
            get { return "vision"; }
        }

        /// <summary>Gets the service base URI.</summary>
        public override string BaseUri
        {
            get { return "https://vision.googleapis.com/"; }
        }

        /// <summary>Gets the service base path.</summary>
        public override string BasePath
        {
            get { return ""; }
        }

        /// <summary>Available OAuth 2.0 scopes for use with the Google Cloud Vision API.</summary>
        public class Scope
        {
            /// <summary>View and manage your data across Google Cloud Platform services</summary>
            public static string CloudPlatform = "https://www.googleapis.com/auth/cloud-platform";

        }



        private readonly ImagesResource images;

        /// <summary>Gets the Images resource.</summary>
        public virtual ImagesResource Images
        {
            get { return images; }
        }
    }

    ///<summary>A base abstract class for Vision requests.</summary>
    public abstract class VisionBaseServiceRequest<TResponse> : Google.Apis.Requests.ClientServiceRequest<TResponse>
    {
        ///<summary>Constructs a new VisionBaseServiceRequest instance.</summary>
        protected VisionBaseServiceRequest(Google.Apis.Services.IClientService service)
            : base(service)
        {
        }

        /// <summary>V1 error format.</summary>
        [Google.Apis.Util.RequestParameterAttribute("$.xgafv", Google.Apis.Util.RequestParameterType.Query)]
        public virtual System.Nullable<XgafvEnum> Xgafv { get; set; }

        /// <summary>V1 error format.</summary>
        public enum XgafvEnum
        {
            /// <summary>v1 error format</summary>
            [Google.Apis.Util.StringValueAttribute("1")]
            Value1,
            /// <summary>v2 error format</summary>
            [Google.Apis.Util.StringValueAttribute("2")]
            Value2,
        }

        /// <summary>OAuth access token.</summary>
        [Google.Apis.Util.RequestParameterAttribute("access_token", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string AccessToken { get; set; }

        /// <summary>Data format for response.</summary>
        /// [default: json]
        [Google.Apis.Util.RequestParameterAttribute("alt", Google.Apis.Util.RequestParameterType.Query)]
        public virtual System.Nullable<AltEnum> Alt { get; set; }

        /// <summary>Data format for response.</summary>
        public enum AltEnum
        {
            /// <summary>Responses with Content-Type of application/json</summary>
            [Google.Apis.Util.StringValueAttribute("json")]
            Json,
            /// <summary>Media download with context-dependent Content-Type</summary>
            [Google.Apis.Util.StringValueAttribute("media")]
            Media,
            /// <summary>Responses with Content-Type of application/x-protobuf</summary>
            [Google.Apis.Util.StringValueAttribute("proto")]
            Proto,
        }

        /// <summary>OAuth bearer token.</summary>
        [Google.Apis.Util.RequestParameterAttribute("bearer_token", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string BearerToken { get; set; }

        /// <summary>JSONP</summary>
        [Google.Apis.Util.RequestParameterAttribute("callback", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string Callback { get; set; }

        /// <summary>Selector specifying which fields to include in a partial response.</summary>
        [Google.Apis.Util.RequestParameterAttribute("fields", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string Fields { get; set; }

        /// <summary>API key. Your API key identifies your project and provides you with API access, quota, and reports.
        /// Required unless you provide an OAuth 2.0 token.</summary>
        [Google.Apis.Util.RequestParameterAttribute("key", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string Key { get; set; }

        /// <summary>OAuth 2.0 token for the current user.</summary>
        [Google.Apis.Util.RequestParameterAttribute("oauth_token", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string OauthToken { get; set; }

        /// <summary>Pretty-print response.</summary>
        /// [default: true]
        [Google.Apis.Util.RequestParameterAttribute("pp", Google.Apis.Util.RequestParameterType.Query)]
        public virtual System.Nullable<bool> Pp { get; set; }

        /// <summary>Returns response with indentations and line breaks.</summary>
        /// [default: true]
        [Google.Apis.Util.RequestParameterAttribute("prettyPrint", Google.Apis.Util.RequestParameterType.Query)]
        public virtual System.Nullable<bool> PrettyPrint { get; set; }

        /// <summary>Available to use for quota purposes for server-side applications. Can be any arbitrary string
        /// assigned to a user, but should not exceed 40 characters.</summary>
        [Google.Apis.Util.RequestParameterAttribute("quotaUser", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string QuotaUser { get; set; }

        /// <summary>Legacy upload protocol for media (e.g. "media", "multipart").</summary>
        [Google.Apis.Util.RequestParameterAttribute("uploadType", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string UploadType { get; set; }

        /// <summary>Upload protocol for media (e.g. "raw", "multipart").</summary>
        [Google.Apis.Util.RequestParameterAttribute("upload_protocol", Google.Apis.Util.RequestParameterType.Query)]
        public virtual string UploadProtocol { get; set; }

        /// <summary>Initializes Vision parameter list.</summary>
        protected override void InitParameters()
        {
            base.InitParameters();

            RequestParameters.Add(
                "$.xgafv", new Google.Apis.Discovery.Parameter
                {
                    Name = "$.xgafv",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "access_token", new Google.Apis.Discovery.Parameter
                {
                    Name = "access_token",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "alt", new Google.Apis.Discovery.Parameter
                {
                    Name = "alt",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = "json",
                    Pattern = null,
                });
            RequestParameters.Add(
                "bearer_token", new Google.Apis.Discovery.Parameter
                {
                    Name = "bearer_token",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "callback", new Google.Apis.Discovery.Parameter
                {
                    Name = "callback",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "fields", new Google.Apis.Discovery.Parameter
                {
                    Name = "fields",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "key", new Google.Apis.Discovery.Parameter
                {
                    Name = "key",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "oauth_token", new Google.Apis.Discovery.Parameter
                {
                    Name = "oauth_token",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "pp", new Google.Apis.Discovery.Parameter
                {
                    Name = "pp",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = "true",
                    Pattern = null,
                });
            RequestParameters.Add(
                "prettyPrint", new Google.Apis.Discovery.Parameter
                {
                    Name = "prettyPrint",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = "true",
                    Pattern = null,
                });
            RequestParameters.Add(
                "quotaUser", new Google.Apis.Discovery.Parameter
                {
                    Name = "quotaUser",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "uploadType", new Google.Apis.Discovery.Parameter
                {
                    Name = "uploadType",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
            RequestParameters.Add(
                "upload_protocol", new Google.Apis.Discovery.Parameter
                {
                    Name = "upload_protocol",
                    IsRequired = false,
                    ParameterType = "query",
                    DefaultValue = null,
                    Pattern = null,
                });
        }
    }

    /// <summary>The "images" collection of methods.</summary>
    public class ImagesResource
    {
        private const string Resource = "images";

        /// <summary>The service which this resource belongs to.</summary>
        private readonly Google.Apis.Services.IClientService service;

        /// <summary>Constructs a new resource.</summary>
        public ImagesResource(Google.Apis.Services.IClientService service)
        {
            this.service = service;

        }


        /// <summary>Run image detection and annotation for a batch of images.</summary>
        /// <param name="body">The body of the request.</param>
        public virtual AnnotateRequest Annotate(Google.Apis.Vision.v1.Data.BatchAnnotateImagesRequest body)
        {
            return new AnnotateRequest(service, body);
        }

        /// <summary>Run image detection and annotation for a batch of images.</summary>
        public class AnnotateRequest : VisionBaseServiceRequest<Google.Apis.Vision.v1.Data.BatchAnnotateImagesResponse>
        {
            /// <summary>Constructs a new Annotate request.</summary>
            public AnnotateRequest(Google.Apis.Services.IClientService service, Google.Apis.Vision.v1.Data.BatchAnnotateImagesRequest body)
                : base(service)
            {
                Body = body;
                InitParameters();
            }



            /// <summary>Gets or sets the body of this request.</summary>
            Google.Apis.Vision.v1.Data.BatchAnnotateImagesRequest Body { get; set; }

            ///<summary>Returns the body of the request.</summary>
            protected override object GetBody() { return Body; }

            ///<summary>Gets the method name.</summary>
            public override string MethodName
            {
                get { return "annotate"; }
            }

            ///<summary>Gets the HTTP method.</summary>
            public override string HttpMethod
            {
                get { return "POST"; }
            }

            ///<summary>Gets the REST path.</summary>
            public override string RestPath
            {
                get { return "v1/images:annotate"; }
            }

            /// <summary>Initializes Annotate parameter list.</summary>
            protected override void InitParameters()
            {
                base.InitParameters();

            }

        }
    }
}

namespace Google.Apis.Vision.v1.Data
{    

    /// <summary>Request for performing Google Cloud Vision API tasks over a user-provided image, with user-requested
    /// features.</summary>
    public class AnnotateImageRequest : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Requested features.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("features")]
        public virtual System.Collections.Generic.IList<Feature> Features { get; set; } 

        /// <summary>The image to be processed.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("image")]
        public virtual Image Image { get; set; } 

        /// <summary>Additional context that may accompany the image.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("imageContext")]
        public virtual ImageContext ImageContext { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Response to an image annotation request.</summary>
    public class AnnotateImageResponse : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>If present, crop hints have completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("cropHintsAnnotation")]
        public virtual CropHintsAnnotation CropHintsAnnotation { get; set; } 

        /// <summary>If set, represents the error message for the operation. Note that filled-in image annotations are
        /// guaranteed to be correct, even when `error` is set.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("error")]
        public virtual Status Error { get; set; } 

        /// <summary>If present, face detection has completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("faceAnnotations")]
        public virtual System.Collections.Generic.IList<FaceAnnotation> FaceAnnotations { get; set; } 

        /// <summary>If present, text (OCR) detection or document (OCR) text detection has completed successfully. This
        /// annotation provides the structural hierarchy for the OCR detected text.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("fullTextAnnotation")]
        public virtual TextAnnotation FullTextAnnotation { get; set; } 

        /// <summary>If present, image properties were extracted successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("imagePropertiesAnnotation")]
        public virtual ImageProperties ImagePropertiesAnnotation { get; set; } 

        /// <summary>If present, label detection has completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("labelAnnotations")]
        public virtual System.Collections.Generic.IList<EntityAnnotation> LabelAnnotations { get; set; } 

        /// <summary>If present, landmark detection has completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("landmarkAnnotations")]
        public virtual System.Collections.Generic.IList<EntityAnnotation> LandmarkAnnotations { get; set; } 

        /// <summary>If present, logo detection has completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("logoAnnotations")]
        public virtual System.Collections.Generic.IList<EntityAnnotation> LogoAnnotations { get; set; } 

        /// <summary>If present, safe-search annotation has completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("safeSearchAnnotation")]
        public virtual SafeSearchAnnotation SafeSearchAnnotation { get; set; } 

        /// <summary>If present, text (OCR) detection has completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("textAnnotations")]
        public virtual System.Collections.Generic.IList<EntityAnnotation> TextAnnotations { get; set; } 

        /// <summary>If present, web detection has completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("webDetection")]
        public virtual WebDetection WebDetection { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Multiple image annotation requests are batched into a single service call.</summary>
    public class BatchAnnotateImagesRequest : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Individual image annotation requests for this batch.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("requests")]
        public virtual System.Collections.Generic.IList<AnnotateImageRequest> Requests { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Response to a batch image annotation request.</summary>
    public class BatchAnnotateImagesResponse : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Individual responses to image annotation requests within the batch.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("responses")]
        public virtual System.Collections.Generic.IList<AnnotateImageResponse> Responses { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Logical element on the page.</summary>
    public class Block : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Detected block type (text, image etc) for this block.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("blockType")]
        public virtual string BlockType { get; set; } 

        /// <summary>The bounding box for the block. The vertices are in the order of top-left, top-right, bottom-right,
        /// bottom-left. When a rotation of the bounding box is detected the rotation is represented as around the top-
        /// left corner as defined when the text is read in the 'natural' orientation. For example: * when the text is
        /// horizontal it might look like: 0----1 |    | 3----2 * when it's rotated 180 degrees around the top-left
        /// corner it becomes: 2----3 |    | 1----0 and the vertice order will still be (0, 1, 2, 3).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("boundingBox")]
        public virtual BoundingPoly BoundingBox { get; set; } 

        /// <summary>List of paragraphs in this block (if this blocks is of type text).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("paragraphs")]
        public virtual System.Collections.Generic.IList<Paragraph> Paragraphs { get; set; } 

        /// <summary>Additional information detected for the block.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("property")]
        public virtual TextProperty Property { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A bounding polygon for the detected image annotation.</summary>
    public class BoundingPoly : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The bounding polygon vertices.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("vertices")]
        public virtual System.Collections.Generic.IList<Vertex> Vertices { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Represents a color in the RGBA color space. This representation is designed for simplicity of
    /// conversion to/from color representations in various languages over compactness; for example, the fields of this
    /// representation can be trivially provided to the constructor of "java.awt.Color" in Java; it can also be
    /// trivially provided to UIColor's "+colorWithRed:green:blue:alpha" method in iOS; and, with just a little work, it
    /// can be easily formatted into a CSS "rgba()" string in JavaScript, as well. Here are some examples:
    ///
    /// Example (Java):
    ///
    /// import com.google.type.Color;
    ///
    /// // ... public static java.awt.Color fromProto(Color protocolor) { float alpha = protocolor.hasAlpha() ?
    /// protocolor.getAlpha().getValue() : 1.0;
    ///
    /// return new java.awt.Color( protocolor.getRed(), protocolor.getGreen(), protocolor.getBlue(), alpha); }
    ///
    /// public static Color toProto(java.awt.Color color) { float red = (float) color.getRed(); float green = (float)
    /// color.getGreen(); float blue = (float) color.getBlue(); float denominator = 255.0; Color.Builder resultBuilder =
    /// Color .newBuilder() .setRed(red / denominator) .setGreen(green / denominator) .setBlue(blue / denominator); int
    /// alpha = color.getAlpha(); if (alpha != 255) { result.setAlpha( FloatValue .newBuilder() .setValue(((float)
    /// alpha) / denominator) .build()); } return resultBuilder.build(); } // ...
    ///
    /// Example (iOS / Obj-C):
    ///
    /// // ... static UIColor* fromProto(Color* protocolor) { float red = [protocolor red]; float green = [protocolor
    /// green]; float blue = [protocolor blue]; FloatValue* alpha_wrapper = [protocolor alpha]; float alpha = 1.0; if
    /// (alpha_wrapper != nil) { alpha = [alpha_wrapper value]; } return [UIColor colorWithRed:red green:green blue:blue
    /// alpha:alpha]; }
    ///
    /// static Color* toProto(UIColor* color) { CGFloat red, green, blue, alpha; if (![color getRed: green: blue:
    /// alpha:]) { return nil; } Color* result = [Color alloc] init]; [result setRed:red]; [result setGreen:green];
    /// [result setBlue:blue]; if (alpha <= 0.9999) { [result setAlpha:floatWrapperWithValue(alpha)]; } [result
    /// autorelease]; return result; } // ...
    ///
    /// Example (JavaScript):
    ///
    /// // ...
    ///
    /// var protoToCssColor = function(rgb_color) { var redFrac = rgb_color.red || 0.0; var greenFrac = rgb_color.green
    /// || 0.0; var blueFrac = rgb_color.blue || 0.0; var red = Math.floor(redFrac * 255); var green =
    /// Math.floor(greenFrac * 255); var blue = Math.floor(blueFrac * 255);
    ///
    /// if (!('alpha' in rgb_color)) { return rgbToCssColor_(red, green, blue); }
    ///
    /// var alphaFrac = rgb_color.alpha.value || 0.0; var rgbParams = [red, green, blue].join(','); return ['rgba(',
    /// rgbParams, ',', alphaFrac, ')'].join(''); };
    ///
    /// var rgbToCssColor_ = function(red, green, blue) { var rgbNumber = new Number((red << 16) | (green << 8) | blue);
    /// var hexString = rgbNumber.toString(16); var missingZeros = 6 - hexString.length; var resultBuilder = ['#']; for
    /// (var i = 0; i < missingZeros; i++) { resultBuilder.push('0'); } resultBuilder.push(hexString); return
    /// resultBuilder.join(''); };
    ///
    /// // ...</summary>
    public class Color : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The fraction of this color that should be applied to the pixel. That is, the final pixel color is
        /// defined by the equation:
        ///
        /// pixel color = alpha * (this color) + (1.0 - alpha) * (background color)
        ///
        /// This means that a value of 1.0 corresponds to a solid color, whereas a value of 0.0 corresponds to a
        /// completely transparent color. This uses a wrapper message rather than a simple float scalar so that it is
        /// possible to distinguish between a default value and the value being unset. If omitted, this color object is
        /// to be rendered as a solid color (as if the alpha value had been explicitly given with a value of
        /// 1.0).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("alpha")]
        public virtual System.Nullable<float> Alpha { get; set; } 

        /// <summary>The amount of blue in the color as a value in the interval [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("blue")]
        public virtual System.Nullable<float> Blue { get; set; } 

        /// <summary>The amount of green in the color as a value in the interval [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("green")]
        public virtual System.Nullable<float> Green { get; set; } 

        /// <summary>The amount of red in the color as a value in the interval [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("red")]
        public virtual System.Nullable<float> Red { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Color information consists of RGB channels, score, and the fraction of the image that the color
    /// occupies in the image.</summary>
    public class ColorInfo : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>RGB components of the color.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("color")]
        public virtual Color Color { get; set; } 

        /// <summary>The fraction of pixels the color occupies in the image. Value in range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pixelFraction")]
        public virtual System.Nullable<float> PixelFraction { get; set; } 

        /// <summary>Image-specific score for this color. Value in range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("score")]
        public virtual System.Nullable<float> Score { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Single crop hint that is used to generate a new crop when serving an image.</summary>
    public class CropHint : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The bounding polygon for the crop region. The coordinates of the bounding box are in the original
        /// image's scale, as returned in `ImageParams`.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("boundingPoly")]
        public virtual BoundingPoly BoundingPoly { get; set; } 

        /// <summary>Confidence of this being a salient region.  Range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("confidence")]
        public virtual System.Nullable<float> Confidence { get; set; } 

        /// <summary>Fraction of importance of this salient region with respect to the original image.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("importanceFraction")]
        public virtual System.Nullable<float> ImportanceFraction { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Set of crop hints that are used to generate new crops when serving images.</summary>
    public class CropHintsAnnotation : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Crop hint results.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("cropHints")]
        public virtual System.Collections.Generic.IList<CropHint> CropHints { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Parameters for crop hints annotation request.</summary>
    public class CropHintsParams : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Aspect ratios in floats, representing the ratio of the width to the height of the image. For
        /// example, if the desired aspect ratio is 4/3, the corresponding float value should be 1.33333.  If not
        /// specified, the best possible crop is returned. The number of provided aspect ratios is limited to a maximum
        /// of 16; any aspect ratios provided after the 16th are ignored.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("aspectRatios")]
        public virtual System.Collections.Generic.IList<System.Nullable<float>> AspectRatios { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Detected start or end of a structural component.</summary>
    public class DetectedBreak : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>True if break prepends the element.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("isPrefix")]
        public virtual System.Nullable<bool> IsPrefix { get; set; } 

        /// <summary>Detected break type.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("type")]
        public virtual string Type { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Detected language for a structural component.</summary>
    public class DetectedLanguage : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Confidence of detected language. Range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("confidence")]
        public virtual System.Nullable<float> Confidence { get; set; } 

        /// <summary>The BCP-47 language code, such as "en-US" or "sr-Latn". For more information, see
        /// http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("languageCode")]
        public virtual string LanguageCode { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Set of dominant colors and their corresponding scores.</summary>
    public class DominantColorsAnnotation : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>RGB color values with their score and pixel fraction.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("colors")]
        public virtual System.Collections.Generic.IList<ColorInfo> Colors { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Set of detected entity features.</summary>
    public class EntityAnnotation : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Image region to which this entity belongs. Currently not produced for `LABEL_DETECTION` features.
        /// For `TEXT_DETECTION` (OCR), `boundingPoly`s are produced for the entire text detected in an image region,
        /// followed by `boundingPoly`s for each word within the detected text.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("boundingPoly")]
        public virtual BoundingPoly BoundingPoly { get; set; } 

        /// <summary>The accuracy of the entity detection in an image. For example, for an image in which the "Eiffel
        /// Tower" entity is detected, this field represents the confidence that there is a tower in the query image.
        /// Range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("confidence")]
        public virtual System.Nullable<float> Confidence { get; set; } 

        /// <summary>Entity textual description, expressed in its `locale` language.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("description")]
        public virtual string Description { get; set; } 

        /// <summary>The language code for the locale in which the entity textual `description` is expressed.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("locale")]
        public virtual string Locale { get; set; } 

        /// <summary>The location information for the detected entity. Multiple `LocationInfo` elements can be present
        /// because one location may indicate the location of the scene in the image, and another location may indicate
        /// the location of the place where the image was taken. Location information is usually present for
        /// landmarks.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("locations")]
        public virtual System.Collections.Generic.IList<LocationInfo> Locations { get; set; } 

        /// <summary>Opaque entity ID. Some IDs may be available in [Google Knowledge Graph Search
        /// API](https://developers.google.com/knowledge-graph/).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("mid")]
        public virtual string Mid { get; set; } 

        /// <summary>Some entities may have optional user-supplied `Property` (name/value) fields, such a score or
        /// string that qualifies the entity.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("properties")]
        public virtual System.Collections.Generic.IList<Property> Properties { get; set; } 

        /// <summary>Overall score of the result. Range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("score")]
        public virtual System.Nullable<float> Score { get; set; } 

        /// <summary>The relevancy of the ICA (Image Content Annotation) label to the image. For example, the relevancy
        /// of "tower" is likely higher to an image containing the detected "Eiffel Tower" than to an image containing a
        /// detected distant towering building, even though the confidence that there is a tower in each image may be
        /// the same. Range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("topicality")]
        public virtual System.Nullable<float> Topicality { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A face annotation object contains the results of face detection.</summary>
    public class FaceAnnotation : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Anger likelihood.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("angerLikelihood")]
        public virtual string AngerLikelihood { get; set; } 

        /// <summary>Blurred likelihood.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("blurredLikelihood")]
        public virtual string BlurredLikelihood { get; set; } 

        /// <summary>The bounding polygon around the face. The coordinates of the bounding box are in the original
        /// image's scale, as returned in `ImageParams`. The bounding box is computed to "frame" the face in accordance
        /// with human expectations. It is based on the landmarker results. Note that one or more x and/or y coordinates
        /// may not be generated in the `BoundingPoly` (the polygon will be unbounded) if only a partial face appears in
        /// the image to be annotated.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("boundingPoly")]
        public virtual BoundingPoly BoundingPoly { get; set; } 

        /// <summary>Detection confidence. Range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("detectionConfidence")]
        public virtual System.Nullable<float> DetectionConfidence { get; set; } 

        /// <summary>The `fd_bounding_poly` bounding polygon is tighter than the `boundingPoly`, and encloses only the
        /// skin part of the face. Typically, it is used to eliminate the face from any image analysis that detects the
        /// "amount of skin" visible in an image. It is not based on the landmarker results, only on the initial face
        /// detection, hence the fd (face detection) prefix.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("fdBoundingPoly")]
        public virtual BoundingPoly FdBoundingPoly { get; set; } 

        /// <summary>Headwear likelihood.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("headwearLikelihood")]
        public virtual string HeadwearLikelihood { get; set; } 

        /// <summary>Joy likelihood.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("joyLikelihood")]
        public virtual string JoyLikelihood { get; set; } 

        /// <summary>Face landmarking confidence. Range [0, 1].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("landmarkingConfidence")]
        public virtual System.Nullable<float> LandmarkingConfidence { get; set; } 

        /// <summary>Detected face landmarks.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("landmarks")]
        public virtual System.Collections.Generic.IList<Landmark> Landmarks { get; set; } 

        /// <summary>Yaw angle, which indicates the leftward/rightward angle that the face is pointing relative to the
        /// vertical plane perpendicular to the image. Range [-180,180].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("panAngle")]
        public virtual System.Nullable<float> PanAngle { get; set; } 

        /// <summary>Roll angle, which indicates the amount of clockwise/anti-clockwise rotation of the face relative to
        /// the image vertical about the axis perpendicular to the face. Range [-180,180].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("rollAngle")]
        public virtual System.Nullable<float> RollAngle { get; set; } 

        /// <summary>Sorrow likelihood.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("sorrowLikelihood")]
        public virtual string SorrowLikelihood { get; set; } 

        /// <summary>Surprise likelihood.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("surpriseLikelihood")]
        public virtual string SurpriseLikelihood { get; set; } 

        /// <summary>Pitch angle, which indicates the upwards/downwards angle that the face is pointing relative to the
        /// image's horizontal plane. Range [-180,180].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("tiltAngle")]
        public virtual System.Nullable<float> TiltAngle { get; set; } 

        /// <summary>Under-exposed likelihood.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("underExposedLikelihood")]
        public virtual string UnderExposedLikelihood { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Users describe the type of Google Cloud Vision API tasks to perform over images by using *Feature*s.
    /// Each Feature indicates a type of image detection task to perform. Features encode the Cloud Vision API vertical
    /// to operate on and the number of top-scoring results to return.</summary>
    public class Feature : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Maximum number of results of this type.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("maxResults")]
        public virtual System.Nullable<int> MaxResults { get; set; } 

        /// <summary>The feature type.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("type")]
        public virtual string Type { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Client image to perform Google Cloud Vision API tasks over.</summary>
    public class Image : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Image content, represented as a stream of bytes. Note: as with all `bytes` fields, protobuffers use
        /// a pure binary representation, whereas JSON representations use base64.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("content")]
        public virtual string Content { get; set; } 

        /// <summary>Google Cloud Storage image location. If both `content` and `source` are provided for an image,
        /// `content` takes precedence and is used to perform the image annotation request.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("source")]
        public virtual ImageSource Source { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Image context and/or feature-specific parameters.</summary>
    public class ImageContext : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Parameters for crop hints annotation request.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("cropHintsParams")]
        public virtual CropHintsParams CropHintsParams { get; set; } 

        /// <summary>List of languages to use for TEXT_DETECTION. In most cases, an empty value yields the best results
        /// since it enables automatic language detection. For languages based on the Latin alphabet, setting
        /// `language_hints` is not needed. In rare cases, when the language of the text in the image is known, setting
        /// a hint will help get better results (although it will be a significant hindrance if the hint is wrong). Text
        /// detection returns an error if one or more of the specified languages is not one of the [supported
        /// languages](/vision/docs/languages).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("languageHints")]
        public virtual System.Collections.Generic.IList<string> LanguageHints { get; set; } 

        /// <summary>lat/long rectangle that specifies the location of the image.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("latLongRect")]
        public virtual LatLongRect LatLongRect { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Stores image properties, such as dominant colors.</summary>
    public class ImageProperties : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>If present, dominant colors completed successfully.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("dominantColors")]
        public virtual DominantColorsAnnotation DominantColors { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>External image source (Google Cloud Storage image location).</summary>
    public class ImageSource : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>NOTE: For new code `image_uri` below is preferred. Google Cloud Storage image URI, which must be in
        /// the following form: `gs://bucket_name/object_name` (for details, see [Google Cloud Storage Request
        /// URIs](https://cloud.google.com/storage/docs/reference-uris)). NOTE: Cloud Storage object versioning is not
        /// supported.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("gcsImageUri")]
        public virtual string GcsImageUri { get; set; } 

        /// <summary>Image URI which supports: 1) Google Cloud Storage image URI, which must be in the following form:
        /// `gs://bucket_name/object_name` (for details, see [Google Cloud Storage Request
        /// URIs](https://cloud.google.com/storage/docs/reference-uris)). NOTE: Cloud Storage object versioning is not
        /// supported. 2) Publicly accessible image HTTP/HTTPS URL. This is preferred over the legacy `gcs_image_uri`
        /// above. When both `gcs_image_uri` and `image_uri` are specified, `image_uri` takes precedence.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("imageUri")]
        public virtual string ImageUri { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A face-specific landmark (for example, a face feature). Landmark positions may fall outside the bounds
    /// of the image if the face is near one or more edges of the image. Therefore it is NOT guaranteed that `0 <= x <
    /// width` or `0 <= y < height`.</summary>
    public class Landmark : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Face landmark position.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("position")]
        public virtual Position Position { get; set; } 

        /// <summary>Face landmark type.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("type")]
        public virtual string Type { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>An object representing a latitude/longitude pair. This is expressed as a pair of doubles representing
    /// degrees latitude and degrees longitude. Unless specified otherwise, this must conform to the WGS84 standard.
    /// Values must be within normalized ranges.
    ///
    /// Example of normalization code in Python:
    ///
    /// def NormalizeLongitude(longitude): Wraps decimal degrees longitude to [-180.0, 180.0]. q, r = divmod(longitude,
    /// 360.0) if r > 180.0 or (r == 180.0 and q <= -1.0): return r - 360.0 return r
    ///
    /// def NormalizeLatLng(latitude, longitude): Wraps decimal degrees latitude and longitude to [-90.0, 90.0] and
    /// [-180.0, 180.0], respectively. r = latitude % 360.0 if r <= 90.0: return r, NormalizeLongitude(longitude) elif r
    /// >= 270.0: return r - 360, NormalizeLongitude(longitude) else: return 180 - r, NormalizeLongitude(longitude +
    /// 180.0)
    ///
    /// assert 180.0 == NormalizeLongitude(180.0) assert -180.0 == NormalizeLongitude(-180.0) assert -179.0 ==
    /// NormalizeLongitude(181.0) assert (0.0, 0.0) == NormalizeLatLng(360.0, 0.0) assert (0.0, 0.0) ==
    /// NormalizeLatLng(-360.0, 0.0) assert (85.0, 180.0) == NormalizeLatLng(95.0, 0.0) assert (-85.0, -170.0) ==
    /// NormalizeLatLng(-95.0, 10.0) assert (90.0, 10.0) == NormalizeLatLng(90.0, 10.0) assert (-90.0, -10.0) ==
    /// NormalizeLatLng(-90.0, -10.0) assert (0.0, -170.0) == NormalizeLatLng(-180.0, 10.0) assert (0.0, -170.0) ==
    /// NormalizeLatLng(180.0, 10.0) assert (-90.0, 10.0) == NormalizeLatLng(270.0, 10.0) assert (90.0, 10.0) ==
    /// NormalizeLatLng(-270.0, 10.0)
    ///
    /// The code in logs/storage/validator/logs_validator_traits.cc treats this type as if it were annotated as
    /// ST_LOCATION.</summary>
    public class LatLng : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The latitude in degrees. It must be in the range [-90.0, +90.0].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("latitude")]
        public virtual System.Nullable<double> Latitude { get; set; } 

        /// <summary>The longitude in degrees. It must be in the range [-180.0, +180.0].</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("longitude")]
        public virtual System.Nullable<double> Longitude { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Rectangle determined by min and max `LatLng` pairs.</summary>
    public class LatLongRect : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Max lat/long pair.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("maxLatLng")]
        public virtual LatLng MaxLatLng { get; set; } 

        /// <summary>Min lat/long pair.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("minLatLng")]
        public virtual LatLng MinLatLng { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Detected entity location information.</summary>
    public class LocationInfo : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>lat/long location coordinates.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("latLng")]
        public virtual LatLng LatLng { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Detected page from OCR.</summary>
    public class Page : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>List of blocks of text, images etc on this page.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("blocks")]
        public virtual System.Collections.Generic.IList<Block> Blocks { get; set; } 

        /// <summary>Page height in pixels.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("height")]
        public virtual System.Nullable<int> Height { get; set; } 

        /// <summary>Additional information detected on the page.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("property")]
        public virtual TextProperty Property { get; set; } 

        /// <summary>Page width in pixels.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("width")]
        public virtual System.Nullable<int> Width { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Structural unit of text representing a number of words in certain order.</summary>
    public class Paragraph : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The bounding box for the paragraph. The vertices are in the order of top-left, top-right, bottom-
        /// right, bottom-left. When a rotation of the bounding box is detected the rotation is represented as around
        /// the top-left corner as defined when the text is read in the 'natural' orientation. For example: * when the
        /// text is horizontal it might look like: 0----1 |    | 3----2 * when it's rotated 180 degrees around the top-
        /// left corner it becomes: 2----3 |    | 1----0 and the vertice order will still be (0, 1, 2, 3).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("boundingBox")]
        public virtual BoundingPoly BoundingBox { get; set; } 

        /// <summary>Additional information detected for the paragraph.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("property")]
        public virtual TextProperty Property { get; set; } 

        /// <summary>List of words in this paragraph.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("words")]
        public virtual System.Collections.Generic.IList<Word> Words { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A 3D position in the image, used primarily for Face detection landmarks. A valid Position must have
    /// both x and y coordinates. The position coordinates are in the same scale as the original image.</summary>
    public class Position : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>X coordinate.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("x")]
        public virtual System.Nullable<float> X { get; set; } 

        /// <summary>Y coordinate.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("y")]
        public virtual System.Nullable<float> Y { get; set; } 

        /// <summary>Z coordinate (or depth).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("z")]
        public virtual System.Nullable<float> Z { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A `Property` consists of a user-supplied name/value pair.</summary>
    public class Property : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Name of the property.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("name")]
        public virtual string Name { get; set; } 

        /// <summary>Value of numeric properties.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("uint64Value")]
        public virtual System.Nullable<ulong> Uint64Value { get; set; } 

        /// <summary>Value of the property.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("value")]
        public virtual string Value { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Set of features pertaining to the image, computed by computer vision methods over safe-search verticals
    /// (for example, adult, spoof, medical, violence).</summary>
    public class SafeSearchAnnotation : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Represents the adult content likelihood for the image.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("adult")]
        public virtual string Adult { get; set; } 

        /// <summary>Likelihood that this is a medical image.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("medical")]
        public virtual string Medical { get; set; } 

        /// <summary>Spoof likelihood. The likelihood that an modification was made to the image's canonical version to
        /// make it appear funny or offensive.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("spoof")]
        public virtual string Spoof { get; set; } 

        /// <summary>Violence likelihood.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("violence")]
        public virtual string Violence { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>The `Status` type defines a logical error model that is suitable for different programming
    /// environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). The error model
    /// is designed to be:
    ///
    /// - Simple to use and understand for most users - Flexible enough to meet unexpected needs
    ///
    /// # Overview
    ///
    /// The `Status` message contains three pieces of data: error code, error message, and error details. The error code
    /// should be an enum value of google.rpc.Code, but it may accept additional error codes if needed.  The error
    /// message should be a developer-facing English message that helps developers *understand* and *resolve* the error.
    /// If a localized user-facing error message is needed, put the localized message in the error details or localize
    /// it in the client. The optional error details may contain arbitrary information about the error. There is a
    /// predefined set of error detail types in the package `google.rpc` which can be used for common error conditions.
    ///
    /// # Language mapping
    ///
    /// The `Status` message is the logical representation of the error model, but it is not necessarily the actual wire
    /// format. When the `Status` message is exposed in different client libraries and different wire protocols, it can
    /// be mapped differently. For example, it will likely be mapped to some exceptions in Java, but more likely mapped
    /// to some error codes in C.
    ///
    /// # Other uses
    ///
    /// The error model and the `Status` message can be used in a variety of environments, either with or without APIs,
    /// to provide a consistent developer experience across different environments.
    ///
    /// Example uses of this error model include:
    ///
    /// - Partial errors. If a service needs to return partial errors to the client, it may embed the `Status` in the
    /// normal response to indicate the partial errors.
    ///
    /// - Workflow errors. A typical workflow has multiple steps. Each step may have a `Status` message for error
    /// reporting purpose.
    ///
    /// - Batch operations. If a client uses batch request and batch response, the `Status` message should be used
    /// directly inside batch response, one for each error sub-response.
    ///
    /// - Asynchronous operations. If an API call embeds asynchronous operation results in its response, the status of
    /// those operations should be represented directly using the `Status` message.
    ///
    /// - Logging. If some API errors are stored in logs, the message `Status` could be used directly after any
    /// stripping needed for security/privacy reasons.</summary>
    public class Status : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The status code, which should be an enum value of google.rpc.Code.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("code")]
        public virtual System.Nullable<int> Code { get; set; } 

        /// <summary>A list of messages that carry the error details.  There will be a common set of message types for
        /// APIs to use.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("details")]
        public virtual System.Collections.Generic.IList<System.Collections.Generic.IDictionary<string,object>> Details { get; set; } 

        /// <summary>A developer-facing error message, which should be in English. Any user-facing error message should
        /// be localized and sent in the google.rpc.Status.details field, or localized by the client.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("message")]
        public virtual string Message { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A single symbol representation.</summary>
    public class Symbol : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The bounding box for the symbol. The vertices are in the order of top-left, top-right, bottom-
        /// right, bottom-left. When a rotation of the bounding box is detected the rotation is represented as around
        /// the top-left corner as defined when the text is read in the 'natural' orientation. For example: * when the
        /// text is horizontal it might look like: 0----1 |    | 3----2 * when it's rotated 180 degrees around the top-
        /// left corner it becomes: 2----3 |    | 1----0 and the vertice order will still be (0, 1, 2, 3).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("boundingBox")]
        public virtual BoundingPoly BoundingBox { get; set; } 

        /// <summary>Additional information detected for the symbol.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("property")]
        public virtual TextProperty Property { get; set; } 

        /// <summary>The actual UTF-8 representation of the symbol.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("text")]
        public virtual string Text { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>TextAnnotation contains a structured representation of OCR extracted text. The hierarchy of an OCR
    /// extracted text structure is like this: TextAnnotation -> Page -> Block -> Paragraph -> Word -> Symbol Each
    /// structural component, starting from Page, may further have their own properties. Properties describe detected
    /// languages, breaks etc.. Please refer to the google.cloud.vision.v1.TextAnnotation.TextProperty message
    /// definition below for more detail.</summary>
    public class TextAnnotation : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>List of pages detected by OCR.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pages")]
        public virtual System.Collections.Generic.IList<Page> Pages { get; set; } 

        /// <summary>UTF-8 text detected on the pages.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("text")]
        public virtual string Text { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Additional information detected on the structural component.</summary>
    public class TextProperty : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Detected start or end of a text segment.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("detectedBreak")]
        public virtual DetectedBreak DetectedBreak { get; set; } 

        /// <summary>A list of detected languages together with confidence.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("detectedLanguages")]
        public virtual System.Collections.Generic.IList<DetectedLanguage> DetectedLanguages { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A vertex represents a 2D point in the image. NOTE: the vertex coordinates are in the same scale as the
    /// original image.</summary>
    public class Vertex : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>X coordinate.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("x")]
        public virtual System.Nullable<int> X { get; set; } 

        /// <summary>Y coordinate.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("y")]
        public virtual System.Nullable<int> Y { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Relevant information for the image from the Internet.</summary>
    public class WebDetection : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Fully matching images from the Internet. They're definite neardups and most often a copy of the
        /// query image with merely a size change.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("fullMatchingImages")]
        public virtual System.Collections.Generic.IList<WebImage> FullMatchingImages { get; set; } 

        /// <summary>Web pages containing the matching images from the Internet.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("pagesWithMatchingImages")]
        public virtual System.Collections.Generic.IList<WebPage> PagesWithMatchingImages { get; set; } 

        /// <summary>Partial matching images from the Internet. Those images are similar enough to share some key-point
        /// features. For example an original image will likely have partial matching for its crops.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("partialMatchingImages")]
        public virtual System.Collections.Generic.IList<WebImage> PartialMatchingImages { get; set; } 

        /// <summary>The visually similar image results.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("visuallySimilarImages")]
        public virtual System.Collections.Generic.IList<WebImage> VisuallySimilarImages { get; set; } 

        /// <summary>Deduced entities from similar images on the Internet.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("webEntities")]
        public virtual System.Collections.Generic.IList<WebEntity> WebEntities { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Entity deduced from similar images on the Internet.</summary>
    public class WebEntity : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Canonical description of the entity, in English.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("description")]
        public virtual string Description { get; set; } 

        /// <summary>Opaque entity ID.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("entityId")]
        public virtual string EntityId { get; set; } 

        /// <summary>Overall relevancy score for the entity. Not normalized and not comparable across different image
        /// queries.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("score")]
        public virtual System.Nullable<float> Score { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Metadata for online images.</summary>
    public class WebImage : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Overall relevancy score for the image. Not normalized and not comparable across different image
        /// queries.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("score")]
        public virtual System.Nullable<float> Score { get; set; } 

        /// <summary>The result image URL.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("url")]
        public virtual string Url { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>Metadata for web pages.</summary>
    public class WebPage : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>Overall relevancy score for the web page. Not normalized and not comparable across different image
        /// queries.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("score")]
        public virtual System.Nullable<float> Score { get; set; } 

        /// <summary>The result web page URL.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("url")]
        public virtual string Url { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }    

    /// <summary>A word representation.</summary>
    public class Word : Google.Apis.Requests.IDirectResponseSchema
    {
        /// <summary>The bounding box for the word. The vertices are in the order of top-left, top-right, bottom-right,
        /// bottom-left. When a rotation of the bounding box is detected the rotation is represented as around the top-
        /// left corner as defined when the text is read in the 'natural' orientation. For example: * when the text is
        /// horizontal it might look like: 0----1 |    | 3----2 * when it's rotated 180 degrees around the top-left
        /// corner it becomes: 2----3 |    | 1----0 and the vertice order will still be (0, 1, 2, 3).</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("boundingBox")]
        public virtual BoundingPoly BoundingBox { get; set; } 

        /// <summary>Additional information detected for the word.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("property")]
        public virtual TextProperty Property { get; set; } 

        /// <summary>List of symbols in the word. The order of the symbols follows the natural reading order.</summary>
        [Newtonsoft.Json.JsonPropertyAttribute("symbols")]
        public virtual System.Collections.Generic.IList<Symbol> Symbols { get; set; } 

        /// <summary>The ETag of the item.</summary>
        public virtual string ETag { get; set; }
    }
}
